home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok77.lha / IFFlib / IFFlib.lha / Examples / AnimExample.c < prev    next >
C/C++ Source or Header  |  1992-06-14  |  6KB  |  267 lines
  1. /*
  2. **
  3. **    $Id: AnimExample.c,v 21.1 92/06/02 18:08:33 chris Exp $
  4. **    $Revision: 21.1 $
  5. **
  6. **    $Filename: Examples/AnimExample.c $
  7. **    $Author: Christian A. Weber $
  8. **    $Release: 21.1 $
  9. **    $Date: 92/06/02 18:08:33 $
  10. **
  11. **    A simple DPaint ANIM player. To compile with Lattice C 5.x, just
  12. **    type 'lmk'. For other compilers you may have to do minor changes.
  13. **
  14. **    THIS IS PD. NO WARRANTY. USE AT YOUR OWN RISK.
  15. **
  16. */
  17.  
  18. #include <proto/exec.h>
  19. #include <proto/graphics.h>
  20. #include <graphics/gfxbase.h>
  21. #include <proto/intuition.h>
  22. #include <dos/dos.h>
  23.  
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27.  
  28. /*
  29. **    If you don't want to put non-Commodore files in the standard
  30. **    include directories, use the SASCOptions program to add the place
  31. **    where you store those non-standard files to your include path.
  32. */
  33. #include <libraries/iff.h>
  34.  
  35. struct Library *IntuitionBase, *IFFBase;
  36. struct GfxBase *GfxBase;
  37.  
  38. int delay;
  39.  
  40. /****************************************************************************
  41. **    Adjust the screen position for overscan pictures in an OS 1.3 compatible
  42. **    way. There are more clever ways to do this under Kickstart 2.x, so you
  43. **    may want to modify this code.
  44. */
  45.  
  46. void SetOverscan(struct Screen *screen)
  47. {
  48.     WORD cols, rows, x=screen->Width, y=screen->Height;
  49.     struct ViewPort    *vp = &(screen->ViewPort);
  50.  
  51.     cols = GfxBase->NormalDisplayColumns>>1;
  52.     rows = GfxBase->NormalDisplayRows; if(rows>300) rows>>=1;
  53.     x -= cols; if(vp->Modes & HIRES) x -= cols;
  54.     y -= rows; if(vp->Modes & LACE)  y -= rows;
  55.     x >>=1; if(x<0) x=0; y >>=1; if(y<0) y=0; if(y>32) y=32;
  56.  
  57.     /*
  58.     **    To avoid color distortions in HAM mode, we must limit the
  59.     **    left edge of the screen to the leftmost value the hardware
  60.     **    can display.
  61.     */
  62.     if(vp->Modes & HAM)
  63.     {
  64.         if(GfxBase->ActiView->DxOffset-x < 96)
  65.             x = GfxBase->ActiView->DxOffset-96;
  66.     }
  67.     vp->DxOffset = -x; vp->DyOffset = -y;
  68.     MakeScreen(screen);
  69.     RethinkDisplay();
  70. }
  71.  
  72.  
  73. /****************************************************************************
  74. **    Load an IFF file and if it's an ANIM, display the animation on a screen.
  75. **    To keep things simple, the double-buffering is done with ScreenToFront().
  76. **    If you want speed, you should use a smarter way.
  77. */
  78.  
  79. void DisplayANIM(char *filename)
  80. {
  81.     IFFL_HANDLE iff;
  82.  
  83.     if(iff = IFFL_OpenIFF(filename, IFFL_MODE_READ) )
  84.     {
  85.         IFFL_HANDLE            form, loopform;
  86.         struct IFFL_BMHD    *bmhd;
  87.         struct Screen        *screen1,*screen2;
  88.         struct NewScreen    ns;
  89.  
  90.  
  91.         /*
  92.         **    First of all, check the file type, and exit if it's not ANIM.
  93.         */
  94.         if( ((ULONG *)iff)[2] != ID_ANIM)
  95.         {
  96.             puts("Not an ANIM file.");
  97.             goto end;
  98.         }
  99.  
  100.         /*
  101.         **    In an ANIM file, each animation frame has its own FORM.
  102.         **    We set up a pointer to the first of these sub-FORMs to get
  103.         **    BMHD and the initial ILBM picture.
  104.         */
  105.         form = (IFFL_HANDLE)((UBYTE *)iff + 12);
  106.  
  107.         if( !(bmhd = IFFL_GetBMHD(form)) )
  108.         {
  109.             puts("This file has no bitmap header.");
  110.             goto end;
  111.         }
  112.  
  113.         /*
  114.         **    Initialize the NewScreen structure, and open two screens.
  115.         */
  116.         memset(&ns, 0, sizeof(ns) );
  117.  
  118.         ns.Type            = CUSTOMSCREEN | SCREENQUIET | SCREENBEHIND;
  119.         ns.Width        = bmhd->w;
  120.         ns.Height        = bmhd->h;
  121.         ns.Depth        = bmhd->nPlanes;
  122.         ns.ViewModes    = IFFL_GetViewModes(form);
  123.  
  124.         if(screen1 = OpenScreen(&ns) )
  125.         {
  126.             if(screen2 = OpenScreen(&ns) )
  127.             {
  128.                 LONG  count, d;
  129.                 UWORD colortable[256];
  130.  
  131.                 SetOverscan(screen1);
  132.                 SetOverscan(screen2);
  133.  
  134.                 count = IFFL_GetColorTab(form, colortable);
  135.  
  136.                 /* Fix for old broken HAM pictures */
  137.                 if(count>32L) count = 32L;
  138.  
  139.                 LoadRGB4(&(screen1->ViewPort), colortable, count);
  140.                 LoadRGB4(&(screen2->ViewPort), colortable, count);
  141.  
  142.  
  143.                 /*
  144.                 **    Decode and display the first frame
  145.                 */
  146.                 if( !IFFL_DecodePic(form, &screen1->BitMap) )
  147.                 {
  148.                     puts("Can't decode picture");
  149.                     goto error;
  150.                 }
  151.  
  152.                 IFFL_DecodePic(form, &screen2->BitMap);
  153.                 ScreenToFront(screen2);
  154.                 for(d=0; d < delay; ++d) WaitTOF();
  155.  
  156.                 /*
  157.                 **    Decode and display the second frame by
  158.                 **    copying the first frame over and modifying it with
  159.                 **    the first DLTA FORM.
  160.                 */
  161.                 form = IFFL_FindChunk(form, 0L);
  162.                 if( !IFFL_ModifyFrame(form, &screen1->BitMap) )
  163.                 {
  164.                     puts("Can't decode frame 1");
  165.                     goto error;
  166.                 }
  167.                 ScreenToFront(screen1);
  168.                 for(d=0; d < delay; ++d) WaitTOF();
  169.  
  170.                 loopform = IFFL_FindChunk(form, 0L);
  171.  
  172.                 /*
  173.                 **    Main loop
  174.                 */
  175.                 for(;;)
  176.                 {
  177.                     for(form = loopform; *(ULONG *)form == ID_FORM; )
  178.                     {
  179.                         /*
  180.                         **    Wait for the left mouse button. Yeah I know
  181.                         **    it's dirty, so don't use it in real apps :)
  182.                         */
  183.                         if(!(*(UBYTE *)0xbfe001 & 0x40))
  184.                             goto error;
  185.  
  186.                         /*
  187.                         **    Prepare the next frame and flip screens
  188.                         */
  189.                         if(IFFL_ModifyFrame(form, &screen2->BitMap) )
  190.                         {
  191.                             struct Screen *dummy;
  192.  
  193.                             dummy=screen1; screen1=screen2; screen2=dummy;
  194.                             ScreenToFront(screen1);
  195.                             for(d=0; d < delay; ++d) WaitTOF();
  196.                         }
  197.                         else
  198.                         {
  199.                             puts("Can't decode frame.");
  200.                             goto error;
  201.                         }
  202.  
  203.                         form = IFFL_FindChunk(form, 0L);
  204.                     }
  205.                 }
  206. error:
  207.                 CloseScreen(screen2);
  208.             }
  209.             else puts("Can't open 2nd screen.");
  210.  
  211.             CloseScreen(screen1);
  212.         }
  213.         else puts("Can't open 1st screen.");
  214. end:
  215.         IFFL_CloseIFF(iff);
  216.     }
  217.     else printf("Can't open file '%s'\n",filename);
  218. }
  219.  
  220.  
  221. /****************************************************************************
  222. **    Main program
  223. */
  224.  
  225. LONG main( int argc, char **argv )
  226. {
  227.     /*
  228.     **    Check command line args
  229.     */
  230.     if( (argc != 3) || !strcmp(argv[1], "?") )
  231.     {
  232.         printf("Usage: %s filename <delaytime>\n", argv[0]);
  233.         return RETURN_FAIL;
  234.     }
  235.  
  236.     delay = atoi(argv[2]);
  237.  
  238.     /*
  239.     **    Open the libraries we need
  240.     */
  241.     if(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0L) )
  242.     {
  243.         if(IntuitionBase = OpenLibrary("intuition.library", 0L) )
  244.         {
  245.             if(IFFBase = OpenLibrary(IFFNAME, IFFVERSION) )
  246.             {
  247.                 /*
  248.                 **    Now show the animation ...
  249.                 */
  250.                 DisplayANIM(argv[1]);
  251.  
  252.                 printf("IFFL_IFFError value is %ld\n", IFFL_IFFError() );
  253.  
  254.                 CloseLibrary(IFFBase);        /* THIS IS VERY IMPORTANT! */
  255.             }
  256.             else printf("Can't open iff.library V%ld+\n", IFFVERSION);
  257.  
  258.             CloseLibrary(IntuitionBase);
  259.         }
  260.  
  261.         CloseLibrary((struct Library *)GfxBase);
  262.     }
  263.  
  264.     return RETURN_OK;
  265. }
  266.  
  267.